package collections;

import org.junit.jupiter.api.Test;

import java.util.*;

/**
 * @author: kejl
 * @create: 2020-09-24 20:32
 */
public class Practice {

   void sortTest(){
       List c = new ArrayList();
       c.add("l");
       c.add("o");
       c.add("v");
       c.add("e");
       System.out.println(c);
       Collections.sort(c);
       System.out.println(c);
    }

    @Test
    void reverse(){
        List list = Arrays.asList("one two three four five six siven".split(" "));
        System.out.println(list);
        Collections.reverse(list);
        System.out.println(list);
    }

    /**
     * fill(List list,Object o)方法的使用(含义：用对象o替换集合list中的所有元素)
     */
   void fill(){
       List m = Arrays.asList("one two three four five six siven".split(" "));
       System.out.println(m);
       Collections.fill(m, "青鸟52T25小龙");
       System.out.println(m);
    }

    /**
     * copy(List m,List n)方法的使用(含义：将集合n中的元素全部复制到m中,并且覆盖相应索引的元素)
     */
    @Test
    void copyList(){
        List m = Arrays.asList("one two three four five six siven".split(" "));
        System.out.println(m);
        List n = Arrays.asList("我 是 复制过来的哈".split(" "));

        System.out.println(m==n);
        System.out.println(n);
        Collections.copy(m,n);
        System.out.println(m);
    }

    /**
     * min(Collection),min(Collection,Comparator)方法的使用(前者采用Collection内含自然比较法，后者采用Comparator进行比较)。
     */
    void min(){
        List c = new ArrayList();
        c.add("l");
        c.add("o");
        c.add("v");
        c.add("e");
        System.out.println(c);
        System.out.println(Collections.min(c));

    }

    /**
     * max(Collection),max(Collection,Comparator)方法的使用(前者采用Collection内含自然比较法，后者采用Comparator进行比较)。
     */
   void  max(){
       List c = new ArrayList();
       c.add("l");
       c.add("o");
       c.add("v");
       c.add("e");
       System.out.println(c);
       System.out.println(Collections.max(c));

    }

    /**
     * indexOfSubList(List list,List subList)方法的使用(含义：查找subList在list中首次出现位置的索引)。
     */
    void indexOfSubList(){
        ArrayList<Integer> intList = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 6, 6, 7, 3));
        ArrayList<Integer> targetList = new ArrayList<>(Arrays.asList(6));
        System.out.println(Collections.indexOfSubList(intList, targetList));
    }

    /**
     * lastIndexOfSubList(List source,List target)方法的使用与上例方法的使用相同
     */
    void lastIndexOfSubList(){
        ArrayList<Integer> intList = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        System.out.println(intList);
        Collections.rotate(intList, -1);
        System.out.println(intList);
    }

    /**
     * rotate(List list,int m)方法的使用(含义：集合中的元素向后移m个位置，在后面被遮盖的元素循环到前面来)。移动列表中的元素，负数向左移动，正数向右移动
     */
    @Test
    void rotatel(){
        ArrayList<Integer> intList = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        System.out.println(intList);
        Collections.rotate(intList, 3);
        System.out.println(intList);
    }

    /**
     * swap(List list,int i,int j)方法的使用(含义：交换集合中指定元素索引的位置)
     */
    @Test
    void swap(){
        List m = Arrays.asList("one two three four five six siven".split(" "));
        System.out.println(m);
        Collections.swap(m, 2, 3);
        System.out.println(m);
    }

    /**
     * binarySearch(Collection,Object)方法的使用(含义：查找指定集合中的元素，返回所查找元素的索引)。
     */
    void binarySearch(){
        List c = new ArrayList();
        c.add("l");
        c.add("o");
        c.add("v");
        c.add("e");
        System.out.println(c);
        int m = Collections.binarySearch(c, "o");
        System.out.println(m);
    }

    /**
     * replaceAll(List list,Object old,Object new)方法的使用(含义：替换批定元素为某元素,若要替换的值存在刚返回true,反之返回false)。
     */
   void replaceAll(){
        List list = Arrays.asList("one two three four five six siven".split(" "));
                System.out.println(list);
        List subList = Arrays.asList("three four five six".split(" "));
                System.out.println(Collections.replaceAll(list, "siven", "siven eight"));
        System.out.println(list);
    }

    /**
     * Collections工具类中提供了多个synchronizedXxx方法，该方法返回指定集合对象对应的同步对象，
     * 从而解决多线程并发访问集合时线程的安全问题。HashSet、ArrayList、HashMap都是线程不安全的，
     * 如果需要考虑同步，则使用这些方法。这些方法主要有：synchronizedSet、synchronizedSortedSet、
     * synchronizedList、synchronizedMap、synchronizedSortedMap。
     * 特别需要指出的是，在使用迭代方法遍历集合时需要手工同步返回的集合!!!
     */
   void synchronizedXxx(){
       Map m = Collections.synchronizedMap(new HashMap());
     // ...
       Set s = m.keySet();  // Needn't be in synchronized block
     // ...
       synchronized (m) {  // Synchronizing on m, not s!
           Iterator i = s.iterator(); // Must be in synchronized block
           while (i.hasNext())
               System.out.println("111");
       //        foo(i.next());
       }
    }

}
